// $ANTLR 3.4 C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g 2012-11-28 16:14:58

package PL.prac10;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

import org.antlr.runtime.tree.*;


@SuppressWarnings({"all", "warnings", "unchecked"})
public class CParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ACORCHETE", "ALLAVE", "AND", "APARENTESIS", "ASTERISCO", "BARRA", "BARRAS", "BLANCO", "BREAK", "CADENA", "CARACTER", "CCORCHETE", "CHAR", "CLLAVE", "COMA", "COMENTARIO", "COMILLA", "COMILLAS", "COMPARADORES", "CPARENTESIS", "DIGITO", "DOSPUNTOS", "ELSE", "ESPACIO", "FLOAT", "FOR", "IDENT", "IF", "IGUAL", "INT", "INTERROGANTE", "LETRA", "LINEA_COMENTARIO", "MAIN", "MAS", "MENOS", "NOT", "NUEVA_LINEA", "NUMERO", "OR", "SEPARADOR", "TIPO", "VOID", "WHILE", "LISTA_INST"
    };

    public static final int EOF=-1;
    public static final int ACORCHETE=4;
    public static final int ALLAVE=5;
    public static final int AND=6;
    public static final int APARENTESIS=7;
    public static final int ASTERISCO=8;
    public static final int BARRA=9;
    public static final int BARRAS=10;
    public static final int BLANCO=11;
    public static final int BREAK=12;
    public static final int CADENA=13;
    public static final int CARACTER=14;
    public static final int CCORCHETE=15;
    public static final int CHAR=16;
    public static final int CLLAVE=17;
    public static final int COMA=18;
    public static final int COMENTARIO=19;
    public static final int COMILLA=20;
    public static final int COMILLAS=21;
    public static final int COMPARADORES=22;
    public static final int CPARENTESIS=23;
    public static final int DIGITO=24;
    public static final int DOSPUNTOS=25;
    public static final int ELSE=26;
    public static final int ESPACIO=27;
    public static final int FLOAT=28;
    public static final int FOR=29;
    public static final int IDENT=30;
    public static final int IF=31;
    public static final int IGUAL=32;
    public static final int INT=33;
    public static final int INTERROGANTE=34;
    public static final int LETRA=35;
    public static final int LINEA_COMENTARIO=36;
    public static final int MAIN=37;
    public static final int MAS=38;
    public static final int MENOS=39;
    public static final int NOT=40;
    public static final int NUEVA_LINEA=41;
    public static final int NUMERO=42;
    public static final int OR=43;
    public static final int SEPARADOR=44;
    public static final int TIPO=45;
    public static final int VOID=46;
    public static final int WHILE=47;
    public static final int LISTA_INST=48;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public CParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public CParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

protected TreeAdaptor adaptor = new CommonTreeAdaptor();

public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}
    public String[] getTokenNames() { return CParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g"; }


    public static class entrada_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "entrada"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:23:1: entrada : ( definicion | cabecera )* EOF -> ^( LISTA_INST ( definicion )* ( cabecera )* ) ;
    public final CParser.entrada_return entrada() throws RecognitionException {
        CParser.entrada_return retval = new CParser.entrada_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token EOF3=null;
        CParser.definicion_return definicion1 =null;

        CParser.cabecera_return cabecera2 =null;


        MiArbol EOF3_tree=null;
        RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
        RewriteRuleSubtreeStream stream_definicion=new RewriteRuleSubtreeStream(adaptor,"rule definicion");
        RewriteRuleSubtreeStream stream_cabecera=new RewriteRuleSubtreeStream(adaptor,"rule cabecera");
        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:23:8: ( ( definicion | cabecera )* EOF -> ^( LISTA_INST ( definicion )* ( cabecera )* ) )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:23:10: ( definicion | cabecera )* EOF
            {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:23:10: ( definicion | cabecera )*
            loop1:
            do {
                int alt1=3;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==TIPO) ) {
                    int LA1_2 = input.LA(2);

                    if ( (LA1_2==IDENT) ) {
                        int LA1_4 = input.LA(3);

                        if ( (LA1_4==COMA||LA1_4==SEPARADOR) ) {
                            alt1=1;
                        }
                        else if ( (LA1_4==APARENTESIS) ) {
                            alt1=2;
                        }


                    }
                    else if ( (LA1_2==MAIN) ) {
                        alt1=2;
                    }


                }
                else if ( (LA1_0==VOID) ) {
                    alt1=2;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:23:11: definicion
            	    {
            	    pushFollow(FOLLOW_definicion_in_entrada80);
            	    definicion1=definicion();

            	    state._fsp--;

            	    stream_definicion.add(definicion1.getTree());

            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:23:22: cabecera
            	    {
            	    pushFollow(FOLLOW_cabecera_in_entrada82);
            	    cabecera2=cabecera();

            	    state._fsp--;

            	    stream_cabecera.add(cabecera2.getTree());

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            EOF3=(Token)match(input,EOF,FOLLOW_EOF_in_entrada86);  
            stream_EOF.add(EOF3);


            // AST REWRITE
            // elements: definicion, cabecera
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (MiArbol)adaptor.nil();
            // 23:37: -> ^( LISTA_INST ( definicion )* ( cabecera )* )
            {
                // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:23:40: ^( LISTA_INST ( definicion )* ( cabecera )* )
                {
                MiArbol root_1 = (MiArbol)adaptor.nil();
                root_1 = (MiArbol)adaptor.becomeRoot(
                (MiArbol)adaptor.create(LISTA_INST, "LISTA_INST")
                , root_1);

                // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:23:53: ( definicion )*
                while ( stream_definicion.hasNext() ) {
                    adaptor.addChild(root_1, stream_definicion.nextTree());

                }
                stream_definicion.reset();

                // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:23:67: ( cabecera )*
                while ( stream_cabecera.hasNext() ) {
                    adaptor.addChild(root_1, stream_cabecera.nextTree());

                }
                stream_cabecera.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;

            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "entrada"


    public static class definicion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "definicion"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:25:1: definicion : TIPO ^ IDENT ( COMA ! IDENT )* SEPARADOR !;
    public final CParser.definicion_return definicion() throws RecognitionException {
        CParser.definicion_return retval = new CParser.definicion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token TIPO4=null;
        Token IDENT5=null;
        Token COMA6=null;
        Token IDENT7=null;
        Token SEPARADOR8=null;

        MiArbol TIPO4_tree=null;
        MiArbol IDENT5_tree=null;
        MiArbol COMA6_tree=null;
        MiArbol IDENT7_tree=null;
        MiArbol SEPARADOR8_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:25:11: ( TIPO ^ IDENT ( COMA ! IDENT )* SEPARADOR !)
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:25:13: TIPO ^ IDENT ( COMA ! IDENT )* SEPARADOR !
            {
            root_0 = (MiArbol)adaptor.nil();


            TIPO4=(Token)match(input,TIPO,FOLLOW_TIPO_in_definicion112); 
            TIPO4_tree = 
            (MiArbol)adaptor.create(TIPO4)
            ;
            root_0 = (MiArbol)adaptor.becomeRoot(TIPO4_tree, root_0);


            IDENT5=(Token)match(input,IDENT,FOLLOW_IDENT_in_definicion115); 
            IDENT5_tree = 
            (MiArbol)adaptor.create(IDENT5)
            ;
            adaptor.addChild(root_0, IDENT5_tree);


            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:25:25: ( COMA ! IDENT )*
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( (LA2_0==COMA) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:25:26: COMA ! IDENT
            	    {
            	    COMA6=(Token)match(input,COMA,FOLLOW_COMA_in_definicion118); 

            	    IDENT7=(Token)match(input,IDENT,FOLLOW_IDENT_in_definicion121); 
            	    IDENT7_tree = 
            	    (MiArbol)adaptor.create(IDENT7)
            	    ;
            	    adaptor.addChild(root_0, IDENT7_tree);


            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);


            SEPARADOR8=(Token)match(input,SEPARADOR,FOLLOW_SEPARADOR_in_definicion125); 

            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "definicion"


    public static class cabecera_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "cabecera"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:1: cabecera : ( VOID | TIPO ) ( IDENT ^| MAIN ^) APARENTESIS ! ( VOID | parametros )? CPARENTESIS ! ALLAVE ! ( cuerpo )* CLLAVE !;
    public final CParser.cabecera_return cabecera() throws RecognitionException {
        CParser.cabecera_return retval = new CParser.cabecera_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token set9=null;
        Token IDENT10=null;
        Token MAIN11=null;
        Token APARENTESIS12=null;
        Token VOID13=null;
        Token CPARENTESIS15=null;
        Token ALLAVE16=null;
        Token CLLAVE18=null;
        CParser.parametros_return parametros14 =null;

        CParser.cuerpo_return cuerpo17 =null;


        MiArbol set9_tree=null;
        MiArbol IDENT10_tree=null;
        MiArbol MAIN11_tree=null;
        MiArbol APARENTESIS12_tree=null;
        MiArbol VOID13_tree=null;
        MiArbol CPARENTESIS15_tree=null;
        MiArbol ALLAVE16_tree=null;
        MiArbol CLLAVE18_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:9: ( ( VOID | TIPO ) ( IDENT ^| MAIN ^) APARENTESIS ! ( VOID | parametros )? CPARENTESIS ! ALLAVE ! ( cuerpo )* CLLAVE !)
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:11: ( VOID | TIPO ) ( IDENT ^| MAIN ^) APARENTESIS ! ( VOID | parametros )? CPARENTESIS ! ALLAVE ! ( cuerpo )* CLLAVE !
            {
            root_0 = (MiArbol)adaptor.nil();


            set9=(Token)input.LT(1);

            if ( (input.LA(1) >= TIPO && input.LA(1) <= VOID) ) {
                input.consume();
                adaptor.addChild(root_0, 
                (MiArbol)adaptor.create(set9)
                );
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:22: ( IDENT ^| MAIN ^)
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==IDENT) ) {
                alt3=1;
            }
            else if ( (LA3_0==MAIN) ) {
                alt3=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;

            }
            switch (alt3) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:23: IDENT ^
                    {
                    IDENT10=(Token)match(input,IDENT,FOLLOW_IDENT_in_cabecera138); 
                    IDENT10_tree = 
                    (MiArbol)adaptor.create(IDENT10)
                    ;
                    root_0 = (MiArbol)adaptor.becomeRoot(IDENT10_tree, root_0);


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:30: MAIN ^
                    {
                    MAIN11=(Token)match(input,MAIN,FOLLOW_MAIN_in_cabecera141); 
                    MAIN11_tree = 
                    (MiArbol)adaptor.create(MAIN11)
                    ;
                    root_0 = (MiArbol)adaptor.becomeRoot(MAIN11_tree, root_0);


                    }
                    break;

            }


            APARENTESIS12=(Token)match(input,APARENTESIS,FOLLOW_APARENTESIS_in_cabecera145); 

            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:50: ( VOID | parametros )?
            int alt4=3;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==VOID) ) {
                alt4=1;
            }
            else if ( (LA4_0==TIPO) ) {
                alt4=2;
            }
            switch (alt4) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:51: VOID
                    {
                    VOID13=(Token)match(input,VOID,FOLLOW_VOID_in_cabecera149); 
                    VOID13_tree = 
                    (MiArbol)adaptor.create(VOID13)
                    ;
                    adaptor.addChild(root_0, VOID13_tree);


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:58: parametros
                    {
                    pushFollow(FOLLOW_parametros_in_cabecera153);
                    parametros14=parametros();

                    state._fsp--;

                    adaptor.addChild(root_0, parametros14.getTree());

                    }
                    break;

            }


            CPARENTESIS15=(Token)match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_cabecera157); 

            ALLAVE16=(Token)match(input,ALLAVE,FOLLOW_ALLAVE_in_cabecera160); 

            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:92: ( cuerpo )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0==BREAK||(LA5_0 >= IDENT && LA5_0 <= IF)||LA5_0==TIPO||LA5_0==WHILE) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:26:92: cuerpo
            	    {
            	    pushFollow(FOLLOW_cuerpo_in_cabecera163);
            	    cuerpo17=cuerpo();

            	    state._fsp--;

            	    adaptor.addChild(root_0, cuerpo17.getTree());

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);


            CLLAVE18=(Token)match(input,CLLAVE,FOLLOW_CLLAVE_in_cabecera166); 

            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "cabecera"


    public static class parametros_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "parametros"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:27:3: parametros : llamada_variable ( COMA ! llamada_variable )* ;
    public final CParser.parametros_return parametros() throws RecognitionException {
        CParser.parametros_return retval = new CParser.parametros_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token COMA20=null;
        CParser.llamada_variable_return llamada_variable19 =null;

        CParser.llamada_variable_return llamada_variable21 =null;


        MiArbol COMA20_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:27:13: ( llamada_variable ( COMA ! llamada_variable )* )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:27:15: llamada_variable ( COMA ! llamada_variable )*
            {
            root_0 = (MiArbol)adaptor.nil();


            pushFollow(FOLLOW_llamada_variable_in_parametros175);
            llamada_variable19=llamada_variable();

            state._fsp--;

            adaptor.addChild(root_0, llamada_variable19.getTree());

            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:27:32: ( COMA ! llamada_variable )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==COMA) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:27:33: COMA ! llamada_variable
            	    {
            	    COMA20=(Token)match(input,COMA,FOLLOW_COMA_in_parametros178); 

            	    pushFollow(FOLLOW_llamada_variable_in_parametros181);
            	    llamada_variable21=llamada_variable();

            	    state._fsp--;

            	    adaptor.addChild(root_0, llamada_variable21.getTree());

            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "parametros"


    public static class llamada_variable_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "llamada_variable"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:28:3: llamada_variable : TIPO ( ASTERISCO )? IDENT ( ACORCHETE CCORCHETE )? ;
    public final CParser.llamada_variable_return llamada_variable() throws RecognitionException {
        CParser.llamada_variable_return retval = new CParser.llamada_variable_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token TIPO22=null;
        Token ASTERISCO23=null;
        Token IDENT24=null;
        Token ACORCHETE25=null;
        Token CCORCHETE26=null;

        MiArbol TIPO22_tree=null;
        MiArbol ASTERISCO23_tree=null;
        MiArbol IDENT24_tree=null;
        MiArbol ACORCHETE25_tree=null;
        MiArbol CCORCHETE26_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:28:19: ( TIPO ( ASTERISCO )? IDENT ( ACORCHETE CCORCHETE )? )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:28:21: TIPO ( ASTERISCO )? IDENT ( ACORCHETE CCORCHETE )?
            {
            root_0 = (MiArbol)adaptor.nil();


            TIPO22=(Token)match(input,TIPO,FOLLOW_TIPO_in_llamada_variable191); 
            TIPO22_tree = 
            (MiArbol)adaptor.create(TIPO22)
            ;
            adaptor.addChild(root_0, TIPO22_tree);


            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:28:26: ( ASTERISCO )?
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0==ASTERISCO) ) {
                alt7=1;
            }
            switch (alt7) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:28:27: ASTERISCO
                    {
                    ASTERISCO23=(Token)match(input,ASTERISCO,FOLLOW_ASTERISCO_in_llamada_variable194); 
                    ASTERISCO23_tree = 
                    (MiArbol)adaptor.create(ASTERISCO23)
                    ;
                    adaptor.addChild(root_0, ASTERISCO23_tree);


                    }
                    break;

            }


            IDENT24=(Token)match(input,IDENT,FOLLOW_IDENT_in_llamada_variable198); 
            IDENT24_tree = 
            (MiArbol)adaptor.create(IDENT24)
            ;
            adaptor.addChild(root_0, IDENT24_tree);


            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:28:45: ( ACORCHETE CCORCHETE )?
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0==ACORCHETE) ) {
                alt8=1;
            }
            switch (alt8) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:28:46: ACORCHETE CCORCHETE
                    {
                    ACORCHETE25=(Token)match(input,ACORCHETE,FOLLOW_ACORCHETE_in_llamada_variable201); 
                    ACORCHETE25_tree = 
                    (MiArbol)adaptor.create(ACORCHETE25)
                    ;
                    adaptor.addChild(root_0, ACORCHETE25_tree);


                    CCORCHETE26=(Token)match(input,CCORCHETE,FOLLOW_CCORCHETE_in_llamada_variable203); 
                    CCORCHETE26_tree = 
                    (MiArbol)adaptor.create(CCORCHETE26)
                    ;
                    adaptor.addChild(root_0, CCORCHETE26_tree);


                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "llamada_variable"


    public static class cuerpo_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "cuerpo"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:3: cuerpo : ( asignacion | definicion | sentencia_break | llamada_funcion | bucle | condicion ) ;
    public final CParser.cuerpo_return cuerpo() throws RecognitionException {
        CParser.cuerpo_return retval = new CParser.cuerpo_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        CParser.asignacion_return asignacion27 =null;

        CParser.definicion_return definicion28 =null;

        CParser.sentencia_break_return sentencia_break29 =null;

        CParser.llamada_funcion_return llamada_funcion30 =null;

        CParser.bucle_return bucle31 =null;

        CParser.condicion_return condicion32 =null;



        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:9: ( ( asignacion | definicion | sentencia_break | llamada_funcion | bucle | condicion ) )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:11: ( asignacion | definicion | sentencia_break | llamada_funcion | bucle | condicion )
            {
            root_0 = (MiArbol)adaptor.nil();


            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:11: ( asignacion | definicion | sentencia_break | llamada_funcion | bucle | condicion )
            int alt9=6;
            switch ( input.LA(1) ) {
            case IDENT:
                {
                int LA9_1 = input.LA(2);

                if ( (LA9_1==IGUAL) ) {
                    alt9=1;
                }
                else if ( (LA9_1==APARENTESIS) ) {
                    alt9=4;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 9, 1, input);

                    throw nvae;

                }
                }
                break;
            case TIPO:
                {
                alt9=2;
                }
                break;
            case BREAK:
                {
                alt9=3;
                }
                break;
            case WHILE:
                {
                alt9=5;
                }
                break;
            case IF:
                {
                alt9=6;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;

            }

            switch (alt9) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:12: asignacion
                    {
                    pushFollow(FOLLOW_asignacion_in_cuerpo217);
                    asignacion27=asignacion();

                    state._fsp--;

                    adaptor.addChild(root_0, asignacion27.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:23: definicion
                    {
                    pushFollow(FOLLOW_definicion_in_cuerpo219);
                    definicion28=definicion();

                    state._fsp--;

                    adaptor.addChild(root_0, definicion28.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:34: sentencia_break
                    {
                    pushFollow(FOLLOW_sentencia_break_in_cuerpo221);
                    sentencia_break29=sentencia_break();

                    state._fsp--;

                    adaptor.addChild(root_0, sentencia_break29.getTree());

                    }
                    break;
                case 4 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:50: llamada_funcion
                    {
                    pushFollow(FOLLOW_llamada_funcion_in_cuerpo223);
                    llamada_funcion30=llamada_funcion();

                    state._fsp--;

                    adaptor.addChild(root_0, llamada_funcion30.getTree());

                    }
                    break;
                case 5 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:66: bucle
                    {
                    pushFollow(FOLLOW_bucle_in_cuerpo225);
                    bucle31=bucle();

                    state._fsp--;

                    adaptor.addChild(root_0, bucle31.getTree());

                    }
                    break;
                case 6 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:30:72: condicion
                    {
                    pushFollow(FOLLOW_condicion_in_cuerpo227);
                    condicion32=condicion();

                    state._fsp--;

                    adaptor.addChild(root_0, condicion32.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "cuerpo"


    public static class llamada_funcion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "llamada_funcion"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:5: llamada_funcion : IDENT ^ APARENTESIS ! ( ( tipos ) ( COMA ! ( tipos )* )? )? CPARENTESIS ! SEPARADOR !;
    public final CParser.llamada_funcion_return llamada_funcion() throws RecognitionException {
        CParser.llamada_funcion_return retval = new CParser.llamada_funcion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token IDENT33=null;
        Token APARENTESIS34=null;
        Token COMA36=null;
        Token CPARENTESIS38=null;
        Token SEPARADOR39=null;
        CParser.tipos_return tipos35 =null;

        CParser.tipos_return tipos37 =null;


        MiArbol IDENT33_tree=null;
        MiArbol APARENTESIS34_tree=null;
        MiArbol COMA36_tree=null;
        MiArbol CPARENTESIS38_tree=null;
        MiArbol SEPARADOR39_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:20: ( IDENT ^ APARENTESIS ! ( ( tipos ) ( COMA ! ( tipos )* )? )? CPARENTESIS ! SEPARADOR !)
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:22: IDENT ^ APARENTESIS ! ( ( tipos ) ( COMA ! ( tipos )* )? )? CPARENTESIS ! SEPARADOR !
            {
            root_0 = (MiArbol)adaptor.nil();


            IDENT33=(Token)match(input,IDENT,FOLLOW_IDENT_in_llamada_funcion238); 
            IDENT33_tree = 
            (MiArbol)adaptor.create(IDENT33)
            ;
            root_0 = (MiArbol)adaptor.becomeRoot(IDENT33_tree, root_0);


            APARENTESIS34=(Token)match(input,APARENTESIS,FOLLOW_APARENTESIS_in_llamada_funcion241); 

            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:42: ( ( tipos ) ( COMA ! ( tipos )* )? )?
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( ((LA12_0 >= CADENA && LA12_0 <= CARACTER)||LA12_0==IDENT||LA12_0==NUMERO) ) {
                alt12=1;
            }
            switch (alt12) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:43: ( tipos ) ( COMA ! ( tipos )* )?
                    {
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:43: ( tipos )
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:44: tipos
                    {
                    pushFollow(FOLLOW_tipos_in_llamada_funcion246);
                    tipos35=tipos();

                    state._fsp--;

                    adaptor.addChild(root_0, tipos35.getTree());

                    }


                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:51: ( COMA ! ( tipos )* )?
                    int alt11=2;
                    int LA11_0 = input.LA(1);

                    if ( (LA11_0==COMA) ) {
                        alt11=1;
                    }
                    switch (alt11) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:52: COMA ! ( tipos )*
                            {
                            COMA36=(Token)match(input,COMA,FOLLOW_COMA_in_llamada_funcion250); 

                            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:58: ( tipos )*
                            loop10:
                            do {
                                int alt10=2;
                                int LA10_0 = input.LA(1);

                                if ( ((LA10_0 >= CADENA && LA10_0 <= CARACTER)||LA10_0==IDENT||LA10_0==NUMERO) ) {
                                    alt10=1;
                                }


                                switch (alt10) {
                            	case 1 :
                            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:31:59: tipos
                            	    {
                            	    pushFollow(FOLLOW_tipos_in_llamada_funcion254);
                            	    tipos37=tipos();

                            	    state._fsp--;

                            	    adaptor.addChild(root_0, tipos37.getTree());

                            	    }
                            	    break;

                            	default :
                            	    break loop10;
                                }
                            } while (true);


                            }
                            break;

                    }


                    }
                    break;

            }


            CPARENTESIS38=(Token)match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_llamada_funcion262); 

            SEPARADOR39=(Token)match(input,SEPARADOR,FOLLOW_SEPARADOR_in_llamada_funcion265); 

            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "llamada_funcion"


    public static class tipos_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "tipos"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:9: tipos : ( ( IDENT ^ ( ACORCHETE ! ( NUMERO ) CCORCHETE !)? ) | NUMERO | CADENA | CARACTER );
    public final CParser.tipos_return tipos() throws RecognitionException {
        CParser.tipos_return retval = new CParser.tipos_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token IDENT40=null;
        Token ACORCHETE41=null;
        Token NUMERO42=null;
        Token CCORCHETE43=null;
        Token NUMERO44=null;
        Token CADENA45=null;
        Token CARACTER46=null;

        MiArbol IDENT40_tree=null;
        MiArbol ACORCHETE41_tree=null;
        MiArbol NUMERO42_tree=null;
        MiArbol CCORCHETE43_tree=null;
        MiArbol NUMERO44_tree=null;
        MiArbol CADENA45_tree=null;
        MiArbol CARACTER46_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:14: ( ( IDENT ^ ( ACORCHETE ! ( NUMERO ) CCORCHETE !)? ) | NUMERO | CADENA | CARACTER )
            int alt14=4;
            switch ( input.LA(1) ) {
            case IDENT:
                {
                alt14=1;
                }
                break;
            case NUMERO:
                {
                alt14=2;
                }
                break;
            case CADENA:
                {
                alt14=3;
                }
                break;
            case CARACTER:
                {
                alt14=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;

            }

            switch (alt14) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:16: ( IDENT ^ ( ACORCHETE ! ( NUMERO ) CCORCHETE !)? )
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:16: ( IDENT ^ ( ACORCHETE ! ( NUMERO ) CCORCHETE !)? )
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:17: IDENT ^ ( ACORCHETE ! ( NUMERO ) CCORCHETE !)?
                    {
                    IDENT40=(Token)match(input,IDENT,FOLLOW_IDENT_in_tipos281); 
                    IDENT40_tree = 
                    (MiArbol)adaptor.create(IDENT40)
                    ;
                    root_0 = (MiArbol)adaptor.becomeRoot(IDENT40_tree, root_0);


                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:24: ( ACORCHETE ! ( NUMERO ) CCORCHETE !)?
                    int alt13=2;
                    int LA13_0 = input.LA(1);

                    if ( (LA13_0==ACORCHETE) ) {
                        alt13=1;
                    }
                    switch (alt13) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:25: ACORCHETE ! ( NUMERO ) CCORCHETE !
                            {
                            ACORCHETE41=(Token)match(input,ACORCHETE,FOLLOW_ACORCHETE_in_tipos285); 

                            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:36: ( NUMERO )
                            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:37: NUMERO
                            {
                            NUMERO42=(Token)match(input,NUMERO,FOLLOW_NUMERO_in_tipos289); 
                            NUMERO42_tree = 
                            (MiArbol)adaptor.create(NUMERO42)
                            ;
                            adaptor.addChild(root_0, NUMERO42_tree);


                            }


                            CCORCHETE43=(Token)match(input,CCORCHETE,FOLLOW_CCORCHETE_in_tipos292); 

                            }
                            break;

                    }


                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:60: NUMERO
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    NUMERO44=(Token)match(input,NUMERO,FOLLOW_NUMERO_in_tipos299); 
                    NUMERO44_tree = 
                    (MiArbol)adaptor.create(NUMERO44)
                    ;
                    adaptor.addChild(root_0, NUMERO44_tree);


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:68: CADENA
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    CADENA45=(Token)match(input,CADENA,FOLLOW_CADENA_in_tipos302); 
                    CADENA45_tree = 
                    (MiArbol)adaptor.create(CADENA45)
                    ;
                    adaptor.addChild(root_0, CADENA45_tree);


                    }
                    break;
                case 4 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:32:75: CARACTER
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    CARACTER46=(Token)match(input,CARACTER,FOLLOW_CARACTER_in_tipos304); 
                    CARACTER46_tree = 
                    (MiArbol)adaptor.create(CARACTER46)
                    ;
                    adaptor.addChild(root_0, CARACTER46_tree);


                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "tipos"


    public static class sentencia_break_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "sentencia_break"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:33:5: sentencia_break : BREAK ^ SEPARADOR !;
    public final CParser.sentencia_break_return sentencia_break() throws RecognitionException {
        CParser.sentencia_break_return retval = new CParser.sentencia_break_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token BREAK47=null;
        Token SEPARADOR48=null;

        MiArbol BREAK47_tree=null;
        MiArbol SEPARADOR48_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:33:20: ( BREAK ^ SEPARADOR !)
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:33:22: BREAK ^ SEPARADOR !
            {
            root_0 = (MiArbol)adaptor.nil();


            BREAK47=(Token)match(input,BREAK,FOLLOW_BREAK_in_sentencia_break314); 
            BREAK47_tree = 
            (MiArbol)adaptor.create(BREAK47)
            ;
            root_0 = (MiArbol)adaptor.becomeRoot(BREAK47_tree, root_0);


            SEPARADOR48=(Token)match(input,SEPARADOR,FOLLOW_SEPARADOR_in_sentencia_break317); 

            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "sentencia_break"


    public static class bucle_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "bucle"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:34:7: bucle : WHILE ^ comparacion sentencia ;
    public final CParser.bucle_return bucle() throws RecognitionException {
        CParser.bucle_return retval = new CParser.bucle_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token WHILE49=null;
        CParser.comparacion_return comparacion50 =null;

        CParser.sentencia_return sentencia51 =null;


        MiArbol WHILE49_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:34:12: ( WHILE ^ comparacion sentencia )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:34:14: WHILE ^ comparacion sentencia
            {
            root_0 = (MiArbol)adaptor.nil();


            WHILE49=(Token)match(input,WHILE,FOLLOW_WHILE_in_bucle330); 
            WHILE49_tree = 
            (MiArbol)adaptor.create(WHILE49)
            ;
            root_0 = (MiArbol)adaptor.becomeRoot(WHILE49_tree, root_0);


            pushFollow(FOLLOW_comparacion_in_bucle333);
            comparacion50=comparacion();

            state._fsp--;

            adaptor.addChild(root_0, comparacion50.getTree());

            pushFollow(FOLLOW_sentencia_in_bucle335);
            sentencia51=sentencia();

            state._fsp--;

            adaptor.addChild(root_0, sentencia51.getTree());

            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "bucle"


    public static class condicion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "condicion"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:35:7: condicion : IF ^ comparacion sentencia ({...}? ( senelse ) |) ;
    public final CParser.condicion_return condicion() throws RecognitionException {
        CParser.condicion_return retval = new CParser.condicion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token IF52=null;
        CParser.comparacion_return comparacion53 =null;

        CParser.sentencia_return sentencia54 =null;

        CParser.senelse_return senelse55 =null;


        MiArbol IF52_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:35:16: ( IF ^ comparacion sentencia ({...}? ( senelse ) |) )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:35:18: IF ^ comparacion sentencia ({...}? ( senelse ) |)
            {
            root_0 = (MiArbol)adaptor.nil();


            IF52=(Token)match(input,IF,FOLLOW_IF_in_condicion347); 
            IF52_tree = 
            (MiArbol)adaptor.create(IF52)
            ;
            root_0 = (MiArbol)adaptor.becomeRoot(IF52_tree, root_0);


            pushFollow(FOLLOW_comparacion_in_condicion350);
            comparacion53=comparacion();

            state._fsp--;

            adaptor.addChild(root_0, comparacion53.getTree());

            pushFollow(FOLLOW_sentencia_in_condicion352);
            sentencia54=sentencia();

            state._fsp--;

            adaptor.addChild(root_0, sentencia54.getTree());

            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:35:44: ({...}? ( senelse ) |)
            int alt15=2;
            int LA15_0 = input.LA(1);

            if ( (LA15_0==ELSE) ) {
                int LA15_1 = input.LA(2);

                if ( (((input.LA(1) == ELSE))) ) {
                    alt15=1;
                }
                else if ( (((input.LA(1) == ELSE))) ) {
                    alt15=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 1, input);

                    throw nvae;

                }
            }
            else if ( (LA15_0==BREAK||LA15_0==CLLAVE||(LA15_0 >= IDENT && LA15_0 <= IF)||LA15_0==TIPO||LA15_0==WHILE) ) {
                alt15=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;

            }
            switch (alt15) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:35:45: {...}? ( senelse )
                    {
                    if ( !(((input.LA(1) == ELSE))) ) {
                        throw new FailedPredicateException(input, "condicion", "(input.LA(1) == ELSE)");
                    }

                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:35:70: ( senelse )
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:35:71: senelse
                    {
                    pushFollow(FOLLOW_senelse_in_condicion358);
                    senelse55=senelse();

                    state._fsp--;

                    adaptor.addChild(root_0, senelse55.getTree());

                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:35:82: 
                    {
                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "condicion"


    public static class senelse_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "senelse"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:36:7: senelse : ELSE ^ sentencia_break ;
    public final CParser.senelse_return senelse() throws RecognitionException {
        CParser.senelse_return retval = new CParser.senelse_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token ELSE56=null;
        CParser.sentencia_break_return sentencia_break57 =null;


        MiArbol ELSE56_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:36:14: ( ELSE ^ sentencia_break )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:36:16: ELSE ^ sentencia_break
            {
            root_0 = (MiArbol)adaptor.nil();


            ELSE56=(Token)match(input,ELSE,FOLLOW_ELSE_in_senelse375); 
            ELSE56_tree = 
            (MiArbol)adaptor.create(ELSE56)
            ;
            root_0 = (MiArbol)adaptor.becomeRoot(ELSE56_tree, root_0);


            pushFollow(FOLLOW_sentencia_break_in_senelse378);
            sentencia_break57=sentencia_break();

            state._fsp--;

            adaptor.addChild(root_0, sentencia_break57.getTree());

            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "senelse"


    public static class sentencia_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "sentencia"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:37:9: sentencia : ( ALLAVE ! ( cuerpo )+ CLLAVE !| cuerpo ) ;
    public final CParser.sentencia_return sentencia() throws RecognitionException {
        CParser.sentencia_return retval = new CParser.sentencia_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token ALLAVE58=null;
        Token CLLAVE60=null;
        CParser.cuerpo_return cuerpo59 =null;

        CParser.cuerpo_return cuerpo61 =null;


        MiArbol ALLAVE58_tree=null;
        MiArbol CLLAVE60_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:37:18: ( ( ALLAVE ! ( cuerpo )+ CLLAVE !| cuerpo ) )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:37:20: ( ALLAVE ! ( cuerpo )+ CLLAVE !| cuerpo )
            {
            root_0 = (MiArbol)adaptor.nil();


            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:37:20: ( ALLAVE ! ( cuerpo )+ CLLAVE !| cuerpo )
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( (LA17_0==ALLAVE) ) {
                alt17=1;
            }
            else if ( (LA17_0==BREAK||(LA17_0 >= IDENT && LA17_0 <= IF)||LA17_0==TIPO||LA17_0==WHILE) ) {
                alt17=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 17, 0, input);

                throw nvae;

            }
            switch (alt17) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:37:21: ALLAVE ! ( cuerpo )+ CLLAVE !
                    {
                    ALLAVE58=(Token)match(input,ALLAVE,FOLLOW_ALLAVE_in_sentencia393); 

                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:37:29: ( cuerpo )+
                    int cnt16=0;
                    loop16:
                    do {
                        int alt16=2;
                        int LA16_0 = input.LA(1);

                        if ( (LA16_0==BREAK||(LA16_0 >= IDENT && LA16_0 <= IF)||LA16_0==TIPO||LA16_0==WHILE) ) {
                            alt16=1;
                        }


                        switch (alt16) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:37:29: cuerpo
                    	    {
                    	    pushFollow(FOLLOW_cuerpo_in_sentencia396);
                    	    cuerpo59=cuerpo();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, cuerpo59.getTree());

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt16 >= 1 ) break loop16;
                                EarlyExitException eee =
                                    new EarlyExitException(16, input);
                                throw eee;
                        }
                        cnt16++;
                    } while (true);


                    CLLAVE60=(Token)match(input,CLLAVE,FOLLOW_CLLAVE_in_sentencia399); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:37:46: cuerpo
                    {
                    pushFollow(FOLLOW_cuerpo_in_sentencia403);
                    cuerpo61=cuerpo();

                    state._fsp--;

                    adaptor.addChild(root_0, cuerpo61.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "sentencia"


    public static class comparacion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "comparacion"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:38:9: comparacion : APARENTESIS ! reglas ( ( AND | OR ) reglas )* CPARENTESIS !;
    public final CParser.comparacion_return comparacion() throws RecognitionException {
        CParser.comparacion_return retval = new CParser.comparacion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token APARENTESIS62=null;
        Token set64=null;
        Token CPARENTESIS66=null;
        CParser.reglas_return reglas63 =null;

        CParser.reglas_return reglas65 =null;


        MiArbol APARENTESIS62_tree=null;
        MiArbol set64_tree=null;
        MiArbol CPARENTESIS66_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:38:20: ( APARENTESIS ! reglas ( ( AND | OR ) reglas )* CPARENTESIS !)
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:38:21: APARENTESIS ! reglas ( ( AND | OR ) reglas )* CPARENTESIS !
            {
            root_0 = (MiArbol)adaptor.nil();


            APARENTESIS62=(Token)match(input,APARENTESIS,FOLLOW_APARENTESIS_in_comparacion417); 

            pushFollow(FOLLOW_reglas_in_comparacion420);
            reglas63=reglas();

            state._fsp--;

            adaptor.addChild(root_0, reglas63.getTree());

            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:38:41: ( ( AND | OR ) reglas )*
            loop18:
            do {
                int alt18=2;
                int LA18_0 = input.LA(1);

                if ( (LA18_0==AND||LA18_0==OR) ) {
                    alt18=1;
                }


                switch (alt18) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:38:42: ( AND | OR ) reglas
            	    {
            	    set64=(Token)input.LT(1);

            	    if ( input.LA(1)==AND||input.LA(1)==OR ) {
            	        input.consume();
            	        adaptor.addChild(root_0, 
            	        (MiArbol)adaptor.create(set64)
            	        );
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_reglas_in_comparacion431);
            	    reglas65=reglas();

            	    state._fsp--;

            	    adaptor.addChild(root_0, reglas65.getTree());

            	    }
            	    break;

            	default :
            	    break loop18;
                }
            } while (true);


            CPARENTESIS66=(Token)match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_comparacion435); 

            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "comparacion"


    public static class reglas_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "reglas"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:39:11: reglas : ( operacion ( COMPARADORES ^ operacion )? | cond_aritmetico ) ;
    public final CParser.reglas_return reglas() throws RecognitionException {
        CParser.reglas_return retval = new CParser.reglas_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token COMPARADORES68=null;
        CParser.operacion_return operacion67 =null;

        CParser.operacion_return operacion69 =null;

        CParser.cond_aritmetico_return cond_aritmetico70 =null;


        MiArbol COMPARADORES68_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:39:17: ( ( operacion ( COMPARADORES ^ operacion )? | cond_aritmetico ) )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:39:18: ( operacion ( COMPARADORES ^ operacion )? | cond_aritmetico )
            {
            root_0 = (MiArbol)adaptor.nil();


            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:39:18: ( operacion ( COMPARADORES ^ operacion )? | cond_aritmetico )
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( (LA20_0==APARENTESIS||LA20_0==NUMERO) ) {
                alt20=1;
            }
            else if ( (LA20_0==IDENT) ) {
                int LA20_2 = input.LA(2);

                if ( (LA20_2==COMPARADORES) ) {
                    int LA20_3 = input.LA(3);

                    if ( (LA20_3==NUMERO) ) {
                        int LA20_4 = input.LA(4);

                        if ( (LA20_4==INTERROGANTE) ) {
                            alt20=2;
                        }
                        else if ( (LA20_4==AND||(LA20_4 >= ASTERISCO && LA20_4 <= BARRA)||LA20_4==CPARENTESIS||(LA20_4 >= MAS && LA20_4 <= MENOS)||LA20_4==OR) ) {
                            alt20=1;
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 20, 4, input);

                            throw nvae;

                        }
                    }
                    else if ( (LA20_3==APARENTESIS||LA20_3==IDENT) ) {
                        alt20=1;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 20, 3, input);

                        throw nvae;

                    }
                }
                else if ( (LA20_2==AND||(LA20_2 >= ASTERISCO && LA20_2 <= BARRA)||LA20_2==CPARENTESIS||(LA20_2 >= MAS && LA20_2 <= MENOS)||LA20_2==OR) ) {
                    alt20=1;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 20, 2, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;

            }
            switch (alt20) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:39:20: operacion ( COMPARADORES ^ operacion )?
                    {
                    pushFollow(FOLLOW_operacion_in_reglas453);
                    operacion67=operacion();

                    state._fsp--;

                    adaptor.addChild(root_0, operacion67.getTree());

                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:39:30: ( COMPARADORES ^ operacion )?
                    int alt19=2;
                    int LA19_0 = input.LA(1);

                    if ( (LA19_0==COMPARADORES) ) {
                        alt19=1;
                    }
                    switch (alt19) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:39:31: COMPARADORES ^ operacion
                            {
                            COMPARADORES68=(Token)match(input,COMPARADORES,FOLLOW_COMPARADORES_in_reglas456); 
                            COMPARADORES68_tree = 
                            (MiArbol)adaptor.create(COMPARADORES68)
                            ;
                            root_0 = (MiArbol)adaptor.becomeRoot(COMPARADORES68_tree, root_0);


                            pushFollow(FOLLOW_operacion_in_reglas459);
                            operacion69=operacion();

                            state._fsp--;

                            adaptor.addChild(root_0, operacion69.getTree());

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:39:57: cond_aritmetico
                    {
                    pushFollow(FOLLOW_cond_aritmetico_in_reglas463);
                    cond_aritmetico70=cond_aritmetico();

                    state._fsp--;

                    adaptor.addChild(root_0, cond_aritmetico70.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "reglas"


    public static class cond_aritmetico_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "cond_aritmetico"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:40:13: cond_aritmetico : IDENT COMPARADORES NUMERO INTERROGANTE NUMERO DOSPUNTOS NUMERO ;
    public final CParser.cond_aritmetico_return cond_aritmetico() throws RecognitionException {
        CParser.cond_aritmetico_return retval = new CParser.cond_aritmetico_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token IDENT71=null;
        Token COMPARADORES72=null;
        Token NUMERO73=null;
        Token INTERROGANTE74=null;
        Token NUMERO75=null;
        Token DOSPUNTOS76=null;
        Token NUMERO77=null;

        MiArbol IDENT71_tree=null;
        MiArbol COMPARADORES72_tree=null;
        MiArbol NUMERO73_tree=null;
        MiArbol INTERROGANTE74_tree=null;
        MiArbol NUMERO75_tree=null;
        MiArbol DOSPUNTOS76_tree=null;
        MiArbol NUMERO77_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:40:28: ( IDENT COMPARADORES NUMERO INTERROGANTE NUMERO DOSPUNTOS NUMERO )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:40:30: IDENT COMPARADORES NUMERO INTERROGANTE NUMERO DOSPUNTOS NUMERO
            {
            root_0 = (MiArbol)adaptor.nil();


            IDENT71=(Token)match(input,IDENT,FOLLOW_IDENT_in_cond_aritmetico482); 
            IDENT71_tree = 
            (MiArbol)adaptor.create(IDENT71)
            ;
            adaptor.addChild(root_0, IDENT71_tree);


            COMPARADORES72=(Token)match(input,COMPARADORES,FOLLOW_COMPARADORES_in_cond_aritmetico484); 
            COMPARADORES72_tree = 
            (MiArbol)adaptor.create(COMPARADORES72)
            ;
            adaptor.addChild(root_0, COMPARADORES72_tree);


            NUMERO73=(Token)match(input,NUMERO,FOLLOW_NUMERO_in_cond_aritmetico486); 
            NUMERO73_tree = 
            (MiArbol)adaptor.create(NUMERO73)
            ;
            adaptor.addChild(root_0, NUMERO73_tree);


            INTERROGANTE74=(Token)match(input,INTERROGANTE,FOLLOW_INTERROGANTE_in_cond_aritmetico488); 
            INTERROGANTE74_tree = 
            (MiArbol)adaptor.create(INTERROGANTE74)
            ;
            adaptor.addChild(root_0, INTERROGANTE74_tree);


            NUMERO75=(Token)match(input,NUMERO,FOLLOW_NUMERO_in_cond_aritmetico490); 
            NUMERO75_tree = 
            (MiArbol)adaptor.create(NUMERO75)
            ;
            adaptor.addChild(root_0, NUMERO75_tree);


            DOSPUNTOS76=(Token)match(input,DOSPUNTOS,FOLLOW_DOSPUNTOS_in_cond_aritmetico492); 
            DOSPUNTOS76_tree = 
            (MiArbol)adaptor.create(DOSPUNTOS76)
            ;
            adaptor.addChild(root_0, DOSPUNTOS76_tree);


            NUMERO77=(Token)match(input,NUMERO,FOLLOW_NUMERO_in_cond_aritmetico494); 
            NUMERO77_tree = 
            (MiArbol)adaptor.create(NUMERO77)
            ;
            adaptor.addChild(root_0, NUMERO77_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "cond_aritmetico"


    public static class asignacion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "asignacion"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:41:7: asignacion : IDENT IGUAL ^ operacion SEPARADOR !;
    public final CParser.asignacion_return asignacion() throws RecognitionException {
        CParser.asignacion_return retval = new CParser.asignacion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token IDENT78=null;
        Token IGUAL79=null;
        Token SEPARADOR81=null;
        CParser.operacion_return operacion80 =null;


        MiArbol IDENT78_tree=null;
        MiArbol IGUAL79_tree=null;
        MiArbol SEPARADOR81_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:41:17: ( IDENT IGUAL ^ operacion SEPARADOR !)
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:41:19: IDENT IGUAL ^ operacion SEPARADOR !
            {
            root_0 = (MiArbol)adaptor.nil();


            IDENT78=(Token)match(input,IDENT,FOLLOW_IDENT_in_asignacion506); 
            IDENT78_tree = 
            (MiArbol)adaptor.create(IDENT78)
            ;
            adaptor.addChild(root_0, IDENT78_tree);


            IGUAL79=(Token)match(input,IGUAL,FOLLOW_IGUAL_in_asignacion508); 
            IGUAL79_tree = 
            (MiArbol)adaptor.create(IGUAL79)
            ;
            root_0 = (MiArbol)adaptor.becomeRoot(IGUAL79_tree, root_0);


            pushFollow(FOLLOW_operacion_in_asignacion511);
            operacion80=operacion();

            state._fsp--;

            adaptor.addChild(root_0, operacion80.getTree());

            SEPARADOR81=(Token)match(input,SEPARADOR,FOLLOW_SEPARADOR_in_asignacion513); 

            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "asignacion"


    public static class operacion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "operacion"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:42:9: operacion : exp_mult ( ( MAS ^| MENOS ^) exp_mult )* ;
    public final CParser.operacion_return operacion() throws RecognitionException {
        CParser.operacion_return retval = new CParser.operacion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token MAS83=null;
        Token MENOS84=null;
        CParser.exp_mult_return exp_mult82 =null;

        CParser.exp_mult_return exp_mult85 =null;


        MiArbol MAS83_tree=null;
        MiArbol MENOS84_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:42:18: ( exp_mult ( ( MAS ^| MENOS ^) exp_mult )* )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:42:20: exp_mult ( ( MAS ^| MENOS ^) exp_mult )*
            {
            root_0 = (MiArbol)adaptor.nil();


            pushFollow(FOLLOW_exp_mult_in_operacion528);
            exp_mult82=exp_mult();

            state._fsp--;

            adaptor.addChild(root_0, exp_mult82.getTree());

            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:42:29: ( ( MAS ^| MENOS ^) exp_mult )*
            loop22:
            do {
                int alt22=2;
                int LA22_0 = input.LA(1);

                if ( ((LA22_0 >= MAS && LA22_0 <= MENOS)) ) {
                    alt22=1;
                }


                switch (alt22) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:42:30: ( MAS ^| MENOS ^) exp_mult
            	    {
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:42:30: ( MAS ^| MENOS ^)
            	    int alt21=2;
            	    int LA21_0 = input.LA(1);

            	    if ( (LA21_0==MAS) ) {
            	        alt21=1;
            	    }
            	    else if ( (LA21_0==MENOS) ) {
            	        alt21=2;
            	    }
            	    else {
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 21, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt21) {
            	        case 1 :
            	            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:42:31: MAS ^
            	            {
            	            MAS83=(Token)match(input,MAS,FOLLOW_MAS_in_operacion532); 
            	            MAS83_tree = 
            	            (MiArbol)adaptor.create(MAS83)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(MAS83_tree, root_0);


            	            }
            	            break;
            	        case 2 :
            	            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:42:36: MENOS ^
            	            {
            	            MENOS84=(Token)match(input,MENOS,FOLLOW_MENOS_in_operacion535); 
            	            MENOS84_tree = 
            	            (MiArbol)adaptor.create(MENOS84)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(MENOS84_tree, root_0);


            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_exp_mult_in_operacion539);
            	    exp_mult85=exp_mult();

            	    state._fsp--;

            	    adaptor.addChild(root_0, exp_mult85.getTree());

            	    }
            	    break;

            	default :
            	    break loop22;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "operacion"


    public static class exp_mult_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exp_mult"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:43:11: exp_mult : exp_base ( ( ASTERISCO ^| BARRA ^) exp_base )* ;
    public final CParser.exp_mult_return exp_mult() throws RecognitionException {
        CParser.exp_mult_return retval = new CParser.exp_mult_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token ASTERISCO87=null;
        Token BARRA88=null;
        CParser.exp_base_return exp_base86 =null;

        CParser.exp_base_return exp_base89 =null;


        MiArbol ASTERISCO87_tree=null;
        MiArbol BARRA88_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:43:19: ( exp_base ( ( ASTERISCO ^| BARRA ^) exp_base )* )
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:43:21: exp_base ( ( ASTERISCO ^| BARRA ^) exp_base )*
            {
            root_0 = (MiArbol)adaptor.nil();


            pushFollow(FOLLOW_exp_base_in_exp_mult557);
            exp_base86=exp_base();

            state._fsp--;

            adaptor.addChild(root_0, exp_base86.getTree());

            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:43:30: ( ( ASTERISCO ^| BARRA ^) exp_base )*
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( ((LA24_0 >= ASTERISCO && LA24_0 <= BARRA)) ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:43:31: ( ASTERISCO ^| BARRA ^) exp_base
            	    {
            	    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:43:31: ( ASTERISCO ^| BARRA ^)
            	    int alt23=2;
            	    int LA23_0 = input.LA(1);

            	    if ( (LA23_0==ASTERISCO) ) {
            	        alt23=1;
            	    }
            	    else if ( (LA23_0==BARRA) ) {
            	        alt23=2;
            	    }
            	    else {
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 23, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt23) {
            	        case 1 :
            	            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:43:32: ASTERISCO ^
            	            {
            	            ASTERISCO87=(Token)match(input,ASTERISCO,FOLLOW_ASTERISCO_in_exp_mult561); 
            	            ASTERISCO87_tree = 
            	            (MiArbol)adaptor.create(ASTERISCO87)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(ASTERISCO87_tree, root_0);


            	            }
            	            break;
            	        case 2 :
            	            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:43:43: BARRA ^
            	            {
            	            BARRA88=(Token)match(input,BARRA,FOLLOW_BARRA_in_exp_mult564); 
            	            BARRA88_tree = 
            	            (MiArbol)adaptor.create(BARRA88)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(BARRA88_tree, root_0);


            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_exp_base_in_exp_mult567);
            	    exp_base89=exp_base();

            	    state._fsp--;

            	    adaptor.addChild(root_0, exp_base89.getTree());

            	    }
            	    break;

            	default :
            	    break loop24;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "exp_mult"


    public static class exp_base_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exp_base"
    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:44:13: exp_base : ( NUMERO | IDENT | ( APARENTESIS ! operacion CPARENTESIS !) );
    public final CParser.exp_base_return exp_base() throws RecognitionException {
        CParser.exp_base_return retval = new CParser.exp_base_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token NUMERO90=null;
        Token IDENT91=null;
        Token APARENTESIS92=null;
        Token CPARENTESIS94=null;
        CParser.operacion_return operacion93 =null;


        MiArbol NUMERO90_tree=null;
        MiArbol IDENT91_tree=null;
        MiArbol APARENTESIS92_tree=null;
        MiArbol CPARENTESIS94_tree=null;

        try {
            // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:44:21: ( NUMERO | IDENT | ( APARENTESIS ! operacion CPARENTESIS !) )
            int alt25=3;
            switch ( input.LA(1) ) {
            case NUMERO:
                {
                alt25=1;
                }
                break;
            case IDENT:
                {
                alt25=2;
                }
                break;
            case APARENTESIS:
                {
                alt25=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;

            }

            switch (alt25) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:44:23: NUMERO
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    NUMERO90=(Token)match(input,NUMERO,FOLLOW_NUMERO_in_exp_base587); 
                    NUMERO90_tree = 
                    (MiArbol)adaptor.create(NUMERO90)
                    ;
                    adaptor.addChild(root_0, NUMERO90_tree);


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:44:32: IDENT
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    IDENT91=(Token)match(input,IDENT,FOLLOW_IDENT_in_exp_base591); 
                    IDENT91_tree = 
                    (MiArbol)adaptor.create(IDENT91)
                    ;
                    adaptor.addChild(root_0, IDENT91_tree);


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:44:40: ( APARENTESIS ! operacion CPARENTESIS !)
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:44:40: ( APARENTESIS ! operacion CPARENTESIS !)
                    // C:\\Users\\Jose\\workspace\\prac10\\src\\main\\java\\analizadores\\CParser.g:44:41: APARENTESIS ! operacion CPARENTESIS !
                    {
                    APARENTESIS92=(Token)match(input,APARENTESIS,FOLLOW_APARENTESIS_in_exp_base596); 

                    pushFollow(FOLLOW_operacion_in_exp_base599);
                    operacion93=operacion();

                    state._fsp--;

                    adaptor.addChild(root_0, operacion93.getTree());

                    CPARENTESIS94=(Token)match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_exp_base601); 

                    }


                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "exp_base"

    // Delegated rules


 

    public static final BitSet FOLLOW_definicion_in_entrada80 = new BitSet(new long[]{0x0000600000000000L});
    public static final BitSet FOLLOW_cabecera_in_entrada82 = new BitSet(new long[]{0x0000600000000000L});
    public static final BitSet FOLLOW_EOF_in_entrada86 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TIPO_in_definicion112 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_IDENT_in_definicion115 = new BitSet(new long[]{0x0000100000040000L});
    public static final BitSet FOLLOW_COMA_in_definicion118 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_IDENT_in_definicion121 = new BitSet(new long[]{0x0000100000040000L});
    public static final BitSet FOLLOW_SEPARADOR_in_definicion125 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_cabecera132 = new BitSet(new long[]{0x0000002040000000L});
    public static final BitSet FOLLOW_IDENT_in_cabecera138 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_MAIN_in_cabecera141 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_APARENTESIS_in_cabecera145 = new BitSet(new long[]{0x0000600000800000L});
    public static final BitSet FOLLOW_VOID_in_cabecera149 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_parametros_in_cabecera153 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_CPARENTESIS_in_cabecera157 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_ALLAVE_in_cabecera160 = new BitSet(new long[]{0x0000A000C0021000L});
    public static final BitSet FOLLOW_cuerpo_in_cabecera163 = new BitSet(new long[]{0x0000A000C0021000L});
    public static final BitSet FOLLOW_CLLAVE_in_cabecera166 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_llamada_variable_in_parametros175 = new BitSet(new long[]{0x0000000000040002L});
    public static final BitSet FOLLOW_COMA_in_parametros178 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_llamada_variable_in_parametros181 = new BitSet(new long[]{0x0000000000040002L});
    public static final BitSet FOLLOW_TIPO_in_llamada_variable191 = new BitSet(new long[]{0x0000000040000100L});
    public static final BitSet FOLLOW_ASTERISCO_in_llamada_variable194 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_IDENT_in_llamada_variable198 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_ACORCHETE_in_llamada_variable201 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_CCORCHETE_in_llamada_variable203 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_asignacion_in_cuerpo217 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_definicion_in_cuerpo219 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_sentencia_break_in_cuerpo221 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_llamada_funcion_in_cuerpo223 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_bucle_in_cuerpo225 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_condicion_in_cuerpo227 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_llamada_funcion238 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_APARENTESIS_in_llamada_funcion241 = new BitSet(new long[]{0x0000040040806000L});
    public static final BitSet FOLLOW_tipos_in_llamada_funcion246 = new BitSet(new long[]{0x0000000000840000L});
    public static final BitSet FOLLOW_COMA_in_llamada_funcion250 = new BitSet(new long[]{0x0000040040806000L});
    public static final BitSet FOLLOW_tipos_in_llamada_funcion254 = new BitSet(new long[]{0x0000040040806000L});
    public static final BitSet FOLLOW_CPARENTESIS_in_llamada_funcion262 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_llamada_funcion265 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_tipos281 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_ACORCHETE_in_tipos285 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_NUMERO_in_tipos289 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_CCORCHETE_in_tipos292 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NUMERO_in_tipos299 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CADENA_in_tipos302 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CARACTER_in_tipos304 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BREAK_in_sentencia_break314 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_sentencia_break317 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHILE_in_bucle330 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_comparacion_in_bucle333 = new BitSet(new long[]{0x0000A000C0001020L});
    public static final BitSet FOLLOW_sentencia_in_bucle335 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_condicion347 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_comparacion_in_condicion350 = new BitSet(new long[]{0x0000A000C0001020L});
    public static final BitSet FOLLOW_sentencia_in_condicion352 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_senelse_in_condicion358 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ELSE_in_senelse375 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_sentencia_break_in_senelse378 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ALLAVE_in_sentencia393 = new BitSet(new long[]{0x0000A000C0001000L});
    public static final BitSet FOLLOW_cuerpo_in_sentencia396 = new BitSet(new long[]{0x0000A000C0021000L});
    public static final BitSet FOLLOW_CLLAVE_in_sentencia399 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_cuerpo_in_sentencia403 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_APARENTESIS_in_comparacion417 = new BitSet(new long[]{0x0000040040000080L});
    public static final BitSet FOLLOW_reglas_in_comparacion420 = new BitSet(new long[]{0x0000080000800040L});
    public static final BitSet FOLLOW_set_in_comparacion423 = new BitSet(new long[]{0x0000040040000080L});
    public static final BitSet FOLLOW_reglas_in_comparacion431 = new BitSet(new long[]{0x0000080000800040L});
    public static final BitSet FOLLOW_CPARENTESIS_in_comparacion435 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_operacion_in_reglas453 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_COMPARADORES_in_reglas456 = new BitSet(new long[]{0x0000040040000080L});
    public static final BitSet FOLLOW_operacion_in_reglas459 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_cond_aritmetico_in_reglas463 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_cond_aritmetico482 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_COMPARADORES_in_cond_aritmetico484 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_NUMERO_in_cond_aritmetico486 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_INTERROGANTE_in_cond_aritmetico488 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_NUMERO_in_cond_aritmetico490 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_DOSPUNTOS_in_cond_aritmetico492 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_NUMERO_in_cond_aritmetico494 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_asignacion506 = new BitSet(new long[]{0x0000000100000000L});
    public static final BitSet FOLLOW_IGUAL_in_asignacion508 = new BitSet(new long[]{0x0000040040000080L});
    public static final BitSet FOLLOW_operacion_in_asignacion511 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_asignacion513 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_exp_mult_in_operacion528 = new BitSet(new long[]{0x000000C000000002L});
    public static final BitSet FOLLOW_MAS_in_operacion532 = new BitSet(new long[]{0x0000040040000080L});
    public static final BitSet FOLLOW_MENOS_in_operacion535 = new BitSet(new long[]{0x0000040040000080L});
    public static final BitSet FOLLOW_exp_mult_in_operacion539 = new BitSet(new long[]{0x000000C000000002L});
    public static final BitSet FOLLOW_exp_base_in_exp_mult557 = new BitSet(new long[]{0x0000000000000302L});
    public static final BitSet FOLLOW_ASTERISCO_in_exp_mult561 = new BitSet(new long[]{0x0000040040000080L});
    public static final BitSet FOLLOW_BARRA_in_exp_mult564 = new BitSet(new long[]{0x0000040040000080L});
    public static final BitSet FOLLOW_exp_base_in_exp_mult567 = new BitSet(new long[]{0x0000000000000302L});
    public static final BitSet FOLLOW_NUMERO_in_exp_base587 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_exp_base591 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_APARENTESIS_in_exp_base596 = new BitSet(new long[]{0x0000040040000080L});
    public static final BitSet FOLLOW_operacion_in_exp_base599 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_CPARENTESIS_in_exp_base601 = new BitSet(new long[]{0x0000000000000002L});

}